home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / gzip.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  11.3 KB  |  458 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import struct
  5. import sys
  6. import time
  7. import zlib
  8. import __builtin__
  9. __all__ = [
  10.     'GzipFile',
  11.     'open']
  12. (FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT) = (1, 2, 4, 8, 16)
  13. (READ, WRITE) = (1, 2)
  14.  
  15. def U32(i):
  16.     if i < 0:
  17.         i += 0x100000000L
  18.     
  19.     return i
  20.  
  21.  
  22. def LOWU32(i):
  23.     return i & 0xFFFFFFFFL
  24.  
  25.  
  26. def write32(output, value):
  27.     output.write(struct.pack('<l', value))
  28.  
  29.  
  30. def write32u(output, value):
  31.     output.write(struct.pack('<L', value))
  32.  
  33.  
  34. def read32(input):
  35.     return struct.unpack('<l', input.read(4))[0]
  36.  
  37.  
  38. def open(filename, mode = 'rb', compresslevel = 9):
  39.     return GzipFile(filename, mode, compresslevel)
  40.  
  41.  
  42. class GzipFile:
  43.     myfileobj = None
  44.     max_read_chunk = 10485760
  45.     
  46.     def __init__(self, filename = None, mode = None, compresslevel = 9, fileobj = None):
  47.         if mode and 'b' not in mode:
  48.             mode += 'b'
  49.         
  50.         if fileobj is None:
  51.             if not mode:
  52.                 pass
  53.             fileobj = self.myfileobj = __builtin__.open(filename, 'rb')
  54.         
  55.         if filename is None:
  56.             if hasattr(fileobj, 'name'):
  57.                 filename = fileobj.name
  58.             else:
  59.                 filename = ''
  60.         
  61.         if mode is None:
  62.             if hasattr(fileobj, 'mode'):
  63.                 mode = fileobj.mode
  64.             else:
  65.                 mode = 'rb'
  66.         
  67.         if mode[0:1] == 'r':
  68.             self.mode = READ
  69.             self._new_member = True
  70.             self.extrabuf = ''
  71.             self.extrasize = 0
  72.             self.filename = filename
  73.             self.min_readsize = 100
  74.         elif mode[0:1] == 'w' or mode[0:1] == 'a':
  75.             self.mode = WRITE
  76.             self._init_write(filename)
  77.             self.compress = zlib.compressobj(compresslevel, zlib.DEFLATED, -(zlib.MAX_WBITS), zlib.DEF_MEM_LEVEL, 0)
  78.         else:
  79.             raise IOError, 'Mode ' + mode + ' not supported'
  80.         self.fileobj = fileobj
  81.         self.offset = 0
  82.         if self.mode == WRITE:
  83.             self._write_gzip_header()
  84.         
  85.  
  86.     
  87.     def __repr__(self):
  88.         s = repr(self.fileobj)
  89.         return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>'
  90.  
  91.     
  92.     def _init_write(self, filename):
  93.         if filename[-3:] != '.gz':
  94.             filename = filename + '.gz'
  95.         
  96.         self.filename = filename
  97.         self.crc = zlib.crc32('')
  98.         self.size = 0
  99.         self.writebuf = []
  100.         self.bufsize = 0
  101.  
  102.     
  103.     def _write_gzip_header(self):
  104.         self.fileobj.write('\x1f\x8b')
  105.         self.fileobj.write('\x08')
  106.         fname = self.filename[:-3]
  107.         flags = 0
  108.         if fname:
  109.             flags = FNAME
  110.         
  111.         self.fileobj.write(chr(flags))
  112.         write32u(self.fileobj, long(time.time()))
  113.         self.fileobj.write('\x02')
  114.         self.fileobj.write('\xff')
  115.         if fname:
  116.             self.fileobj.write(fname + '\x00')
  117.         
  118.  
  119.     
  120.     def _init_read(self):
  121.         self.crc = zlib.crc32('')
  122.         self.size = 0
  123.  
  124.     
  125.     def _read_gzip_header(self):
  126.         magic = self.fileobj.read(2)
  127.         if magic != '\x1f\x8b':
  128.             raise IOError, 'Not a gzipped file'
  129.         
  130.         method = ord(self.fileobj.read(1))
  131.         if method != 8:
  132.             raise IOError, 'Unknown compression method'
  133.         
  134.         flag = ord(self.fileobj.read(1))
  135.         self.fileobj.read(6)
  136.         if flag & FEXTRA:
  137.             xlen = ord(self.fileobj.read(1))
  138.             xlen = xlen + 256 * ord(self.fileobj.read(1))
  139.             self.fileobj.read(xlen)
  140.         
  141.         if flag & FNAME:
  142.             while True:
  143.                 s = self.fileobj.read(1)
  144.                 if not s or s == '\x00':
  145.                     break
  146.                     continue
  147.         
  148.         if flag & FCOMMENT:
  149.             while True:
  150.                 s = self.fileobj.read(1)
  151.                 if not s or s == '\x00':
  152.                     break
  153.                     continue
  154.         
  155.         if flag & FHCRC:
  156.             self.fileobj.read(2)
  157.         
  158.  
  159.     
  160.     def write(self, data):
  161.         if self.mode != WRITE:
  162.             import errno
  163.             raise IOError(errno.EBADF, 'write() on read-only GzipFile object')
  164.         
  165.         if self.fileobj is None:
  166.             raise ValueError, 'write() on closed GzipFile object'
  167.         
  168.         if len(data) > 0:
  169.             self.size = self.size + len(data)
  170.             self.crc = zlib.crc32(data, self.crc)
  171.             self.fileobj.write(self.compress.compress(data))
  172.             self.offset += len(data)
  173.         
  174.  
  175.     
  176.     def read(self, size = -1):
  177.         if self.mode != READ:
  178.             import errno
  179.             raise IOError(errno.EBADF, 'read() on write-only GzipFile object')
  180.         
  181.         if self.extrasize <= 0 and self.fileobj is None:
  182.             return ''
  183.         
  184.         readsize = 1024
  185.         if size < 0:
  186.             
  187.             try:
  188.                 while True:
  189.                     self._read(readsize)
  190.                     readsize = min(self.max_read_chunk, readsize * 2)
  191.             except EOFError:
  192.                 size = self.extrasize
  193.             except:
  194.                 None<EXCEPTION MATCH>EOFError
  195.             
  196.  
  197.         None<EXCEPTION MATCH>EOFError
  198.         
  199.         try:
  200.             while size > self.extrasize:
  201.                 self._read(readsize)
  202.                 readsize = min(self.max_read_chunk, readsize * 2)
  203.         except EOFError:
  204.             if size > self.extrasize:
  205.                 size = self.extrasize
  206.             
  207.         except:
  208.             size > self.extrasize
  209.  
  210.         chunk = self.extrabuf[:size]
  211.         self.extrabuf = self.extrabuf[size:]
  212.         self.extrasize = self.extrasize - size
  213.         self.offset += size
  214.         return chunk
  215.  
  216.     
  217.     def _unread(self, buf):
  218.         self.extrabuf = buf + self.extrabuf
  219.         self.extrasize = len(buf) + self.extrasize
  220.         self.offset -= len(buf)
  221.  
  222.     
  223.     def _read(self, size = 1024):
  224.         if self.fileobj is None:
  225.             raise EOFError, 'Reached EOF'
  226.         
  227.         if self._new_member:
  228.             pos = self.fileobj.tell()
  229.             self.fileobj.seek(0, 2)
  230.             if pos == self.fileobj.tell():
  231.                 raise EOFError, 'Reached EOF'
  232.             else:
  233.                 self.fileobj.seek(pos)
  234.             self._init_read()
  235.             self._read_gzip_header()
  236.             self.decompress = zlib.decompressobj(-(zlib.MAX_WBITS))
  237.             self._new_member = False
  238.         
  239.         buf = self.fileobj.read(size)
  240.         if buf == '':
  241.             uncompress = self.decompress.flush()
  242.             self._read_eof()
  243.             self._add_read_data(uncompress)
  244.             raise EOFError, 'Reached EOF'
  245.         
  246.         uncompress = self.decompress.decompress(buf)
  247.         self._add_read_data(uncompress)
  248.         if self.decompress.unused_data != '':
  249.             self.fileobj.seek(-len(self.decompress.unused_data) + 8, 1)
  250.             self._read_eof()
  251.             self._new_member = True
  252.         
  253.  
  254.     
  255.     def _add_read_data(self, data):
  256.         self.crc = zlib.crc32(data, self.crc)
  257.         self.extrabuf = self.extrabuf + data
  258.         self.extrasize = self.extrasize + len(data)
  259.         self.size = self.size + len(data)
  260.  
  261.     
  262.     def _read_eof(self):
  263.         self.fileobj.seek(-8, 1)
  264.         crc32 = read32(self.fileobj)
  265.         isize = U32(read32(self.fileobj))
  266.         if U32(crc32) != U32(self.crc):
  267.             raise IOError, 'CRC check failed'
  268.         elif isize != LOWU32(self.size):
  269.             raise IOError, 'Incorrect length of data produced'
  270.         
  271.  
  272.     
  273.     def close(self):
  274.         if self.mode == WRITE:
  275.             self.fileobj.write(self.compress.flush())
  276.             write32u(self.fileobj, LOWU32(self.crc))
  277.             write32u(self.fileobj, LOWU32(self.size))
  278.             self.fileobj = None
  279.         elif self.mode == READ:
  280.             self.fileobj = None
  281.         
  282.         if self.myfileobj:
  283.             self.myfileobj.close()
  284.             self.myfileobj = None
  285.         
  286.  
  287.     
  288.     def __del__(self):
  289.         
  290.         try:
  291.             if self.myfileobj is None and self.fileobj is None:
  292.                 return None
  293.         except AttributeError:
  294.             return None
  295.  
  296.         self.close()
  297.  
  298.     
  299.     def flush(self, zlib_mode = zlib.Z_SYNC_FLUSH):
  300.         if self.mode == WRITE:
  301.             self.fileobj.write(self.compress.flush(zlib_mode))
  302.         
  303.         self.fileobj.flush()
  304.  
  305.     
  306.     def fileno(self):
  307.         return self.fileobj.fileno()
  308.  
  309.     
  310.     def isatty(self):
  311.         return False
  312.  
  313.     
  314.     def tell(self):
  315.         return self.offset
  316.  
  317.     
  318.     def rewind(self):
  319.         if self.mode != READ:
  320.             raise IOError("Can't rewind in write mode")
  321.         
  322.         self.fileobj.seek(0)
  323.         self._new_member = True
  324.         self.extrabuf = ''
  325.         self.extrasize = 0
  326.         self.offset = 0
  327.  
  328.     
  329.     def seek(self, offset):
  330.         if self.mode == WRITE:
  331.             if offset < self.offset:
  332.                 raise IOError('Negative seek in write mode')
  333.             
  334.             count = offset - self.offset
  335.             for i in range(count // 1024):
  336.                 self.write(1024 * '\x00')
  337.             
  338.             self.write((count % 1024) * '\x00')
  339.         elif self.mode == READ:
  340.             if offset < self.offset:
  341.                 self.rewind()
  342.             
  343.             count = offset - self.offset
  344.             for i in range(count // 1024):
  345.                 self.read(1024)
  346.             
  347.             self.read(count % 1024)
  348.         
  349.  
  350.     
  351.     def readline(self, size = -1):
  352.         if size < 0:
  353.             size = sys.maxint
  354.             readsize = self.min_readsize
  355.         else:
  356.             readsize = size
  357.         bufs = []
  358.         while size != 0:
  359.             c = self.read(readsize)
  360.             i = c.find('\n')
  361.             if (size <= i or i == -1) and len(c) > size:
  362.                 i = size - 1
  363.             
  364.             if i >= 0 or c == '':
  365.                 bufs.append(c[:i + 1])
  366.                 self._unread(c[i + 1:])
  367.                 break
  368.             
  369.             bufs.append(c)
  370.             size = size - len(c)
  371.             readsize = min(size, readsize * 2)
  372.         if readsize > self.min_readsize:
  373.             self.min_readsize = min(readsize, self.min_readsize * 2, 512)
  374.         
  375.         return ''.join(bufs)
  376.  
  377.     
  378.     def readlines(self, sizehint = 0):
  379.         if sizehint <= 0:
  380.             sizehint = sys.maxint
  381.         
  382.         L = []
  383.         while sizehint > 0:
  384.             line = self.readline()
  385.             if line == '':
  386.                 break
  387.             
  388.             L.append(line)
  389.             sizehint = sizehint - len(line)
  390.         return L
  391.  
  392.     
  393.     def writelines(self, L):
  394.         for line in L:
  395.             self.write(line)
  396.         
  397.  
  398.     
  399.     def __iter__(self):
  400.         return self
  401.  
  402.     
  403.     def next(self):
  404.         line = self.readline()
  405.         if line:
  406.             return line
  407.         else:
  408.             raise StopIteration
  409.  
  410.  
  411.  
  412. def _test():
  413.     args = sys.argv[1:]
  414.     if args:
  415.         pass
  416.     decompress = args[0] == '-d'
  417.     if decompress:
  418.         args = args[1:]
  419.     
  420.     if not args:
  421.         args = [
  422.             '-']
  423.     
  424.     for arg in args:
  425.         if decompress:
  426.             if arg == '-':
  427.                 f = GzipFile(filename = '', mode = 'rb', fileobj = sys.stdin)
  428.                 g = sys.stdout
  429.             elif arg[-3:] != '.gz':
  430.                 print "filename doesn't end in .gz:", repr(arg)
  431.                 continue
  432.             
  433.             f = open(arg, 'rb')
  434.             g = __builtin__.open(arg[:-3], 'wb')
  435.         elif arg == '-':
  436.             f = sys.stdin
  437.             g = GzipFile(filename = '', mode = 'wb', fileobj = sys.stdout)
  438.         else:
  439.             f = __builtin__.open(arg, 'rb')
  440.             g = open(arg + '.gz', 'wb')
  441.         while True:
  442.             chunk = f.read(1024)
  443.             if not chunk:
  444.                 break
  445.             
  446.             g.write(chunk)
  447.         if g is not sys.stdout:
  448.             g.close()
  449.         
  450.         if f is not sys.stdin:
  451.             f.close()
  452.             continue
  453.     
  454.  
  455. if __name__ == '__main__':
  456.     _test()
  457.  
  458.